LISP 0.5 for the Newton is an interpreter for a subset of the LISP language. LISP is a functional list-processing language that supports recursion. It is the language of choice for artificial intelligence applications, and later dialects such as Common LISP and Scheme are currently in active use. The version of LISP implemented by this package is approximately a subset of any modern LISP.
We assume here that the reader is familiar with some dialect of LISP or has found a textbook to explain the rudiments. The LISP application has an output box, some input lines below it, and at the bottom, on the status bar, the buttons "About" and "Eval", plus two keys for typing left and right parentheses conveniently. The Eval button evaluates an S-expression written in the input area, and prints the value in the output box. It is also possible to define functions and constants in a Newton Notes folder and cause them to be read in.
S-expressions are, as usual, atoms or lists. Atom names are delimited by parentheses, blanks, commas, or carriage returns. Atom names are not case-sensitive. Numbers will be recognized as such. Dotted pairs are not supported.
The following functions are built in: atom, append, car, cdr, cond, cons, csetq, equal, eval, input, list, member, null, print, quote, plus, minus, times, div, mod, lessp, zerop. They all correspond to functions usually provided in LISP except for input.
Evaluating (input <filename>) causes input to be taken from the named Notes folder. The input function does not evaluate its argument, so if LISP S-expressions are placed in a Notes folder named "Lisp", for example, then (input lisp) will read in those S-expressions. Only the first S-expression in each note in that folder will be read in, so you must start a new note after each definition.
Use csetq to define functions and constants. For example, (csetq foo (quote (lambda (x) (car x)))) will define foo to be a synonym for car. An atom can have only one value; if that value is a lambda-expression it can be used as a function. The constants t and nil have themselves as values, and so do all numbers.
Final parentheses may be omitted from the input line and from definitions in notes. Thus, "(csetq foo (quote (lambda (x) (car x" is enough to define foo, and "(foo (quote (a b)" is enough to evaluate it on (a b). If more than one S-expression appears on an input line, only the first will be evaluated, and anything following it will be ignored. Double-tap on incorrect input to bring up the keyboard.
No errors will be caught by LISP. Mistakes like trying to take car of an atom or calling a function with too few arguments will result in a Newton error notification.
FUNCTION SUMMARY
Examples or explanations are given below for each built-in function.
(print (quote foo)) prints foo in the output box on the next available line.
(quote a) => a.
(plus 1 2) => 3.
(minus 1) => -1.
(minus 4 2) => 2.
(times 2 3) => 6.
(div 7 2) => 3.
(mod 7 2) => 1.
(lessp 2 2) => nil, (lessp 1 2) => t.
(zerop 0) => t, (zerop 1) => nil.
EXAMPLES
The function "last" finds the last element of a list:
(csetq last (quote (lambda (x) (cond
((atom x) nil)
((null (cdr x)) (car x))
(t (last (cdr x)))))))
(last (quote (a b))) => b.
The function "mapcar" applies the one-argument function named as its first argument to each element of the list given as its second argument, returning the list of values.
(csetq mapcar (quote (lambda (f x) (cond
((atom x) nil)
(t (cons (eval (list f (list (quote quote) (car x))))
(mapcar f (cdr x)))))))
(mapcar (quote car) (quote ((a) (b)))) => (a b).
DISTRIBUTION
LISP 0.5 is freeware and unrestricted, except that this README file must be distributed with it. It was written by Jonathan Millen (JKMillen@aol.com) and the help of Phil Torrone (PDC Phil on AOL) is gratefully acknowledged.
